using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("SoundManager")]
	public class SoundManager : MonoBehaviour
	{
		[Attribute38("SoundManager.ExtensionMapping")]
		public class ExtensionMapping : MonoClass
		{
			public SourceExtension Extension => method_3<SourceExtension>("Extension");

			public ExtensionMapping(IntPtr address, string className)
				: base(address, className)
			{
			}

			public ExtensionMapping(IntPtr address)
				: this(address, "ExtensionMapping")
			{
			}
		}

		[Attribute38("SoundManager.SoundLoadContext")]
		public class SoundLoadContext : MonoClass
		{
			public GameObject m_parent => method_3<GameObject>("m_parent");

			public float m_volume => method_2<float>("m_volume");

			public SceneMgr.Mode m_sceneMode => method_2<SceneMgr.Mode>("m_sceneMode");

			public bool m_haveCallback => method_2<bool>("m_haveCallback");

			public object m_userData => method_3<object>("m_userData");

			public SoundLoadContext(IntPtr address, string className)
				: base(address, className)
			{
			}

			public SoundLoadContext(IntPtr address)
				: this(address, "SoundLoadContext")
			{
			}
		}

		[Attribute38("SoundManager.SourceExtension")]
		public class SourceExtension : MonoClass
		{
			public int m_id => method_2<int>("m_id");

			public float m_codeVolume => method_2<float>("m_codeVolume");

			public float m_sourceVolume => method_2<float>("m_sourceVolume");

			public float m_defVolume => method_2<float>("m_defVolume");

			public float m_codePitch => method_2<float>("m_codePitch");

			public float m_sourcePitch => method_2<float>("m_sourcePitch");

			public float m_defPitch => method_2<float>("m_defPitch");

			public bool m_paused => method_2<bool>("m_paused");

			public bool m_ducking => method_2<bool>("m_ducking");

			public string m_bundleName => method_4("m_bundleName");

			public SourceExtension(IntPtr address, string className)
				: base(address, className)
			{
			}

			public SourceExtension(IntPtr address)
				: this(address, "SourceExtension")
			{
			}
		}

		[Attribute38("SoundManager.BundleInfo")]
		public class BundleInfo : MonoClass
		{
			public AssetReference m_assetRef => method_3<AssetReference>("m_assetRef");

			public bool m_garbageCollect => method_2<bool>("m_garbageCollect");

			public BundleInfo(IntPtr address, string className)
				: base(address, className)
			{
			}

			public BundleInfo(IntPtr address)
				: this(address, "BundleInfo")
			{
			}

			public string GetAssetRef()
			{
				return method_13("GetAssetRef");
			}

			public void SetAssetRef(AssetReference assetRef)
			{
				method_8("SetAssetRef", assetRef);
			}

			public int GetRefCount()
			{
				return method_11<int>("GetRefCount", Array.Empty<object>());
			}

			public bool CanGarbageCollect()
			{
				return method_11<bool>("CanGarbageCollect", Array.Empty<object>());
			}

			public bool IsGarbageCollectEnabled()
			{
				return method_11<bool>("IsGarbageCollectEnabled", Array.Empty<object>());
			}

			public void EnableGarbageCollect(bool enable)
			{
				method_8("EnableGarbageCollect", enable);
			}
		}

		public enum DuckMode
		{
			IDLE,
			BEGINNING,
			HOLD,
			RESTORING
		}

		[Attribute38("SoundManager.DuckState")]
		public class DuckState : MonoClass
		{
			public object m_trigger => method_3<object>("m_trigger");

			public SoundCategory m_triggerCategory => method_2<SoundCategory>("m_triggerCategory");

			public SoundDuckedCategoryDef m_duckedDef => method_3<SoundDuckedCategoryDef>("m_duckedDef");

			public DuckMode m_mode => method_2<DuckMode>("m_mode");

			public string m_tweenName => method_4("m_tweenName");

			public float m_volume => method_2<float>("m_volume");

			public DuckState(IntPtr address, string className)
				: base(address, className)
			{
			}

			public DuckState(IntPtr address)
				: this(address, "DuckState")
			{
			}

			public object GetTrigger()
			{
				return method_14<object>("GetTrigger", Array.Empty<object>());
			}

			public void SetTrigger(object trigger)
			{
				method_8("SetTrigger", trigger);
			}

			public bool IsTrigger(object trigger)
			{
				return method_11<bool>("IsTrigger", new object[1] { trigger });
			}

			public bool IsTriggerAlive()
			{
				return method_11<bool>("IsTriggerAlive", Array.Empty<object>());
			}

			public SoundCategory GetTriggerCategory()
			{
				return method_11<SoundCategory>("GetTriggerCategory", Array.Empty<object>());
			}

			public SoundDuckedCategoryDef GetDuckedDef()
			{
				return method_14<SoundDuckedCategoryDef>("GetDuckedDef", Array.Empty<object>());
			}

			public void SetDuckedDef(SoundDuckedCategoryDef def)
			{
				method_8("SetDuckedDef", def);
			}

			public DuckMode GetMode()
			{
				return method_11<DuckMode>("GetMode", Array.Empty<object>());
			}

			public void SetMode(DuckMode mode)
			{
				method_8("SetMode", mode);
			}

			public string GetTweenName()
			{
				return method_13("GetTweenName");
			}

			public void SetTweenName(string name)
			{
				method_8("SetTweenName", name);
			}

			public float GetVolume()
			{
				return method_11<float>("GetVolume", Array.Empty<object>());
			}

			public void SetVolume(float volume)
			{
				method_8("SetVolume", volume);
			}
		}

		public SoundConfig m_config => method_3<SoundConfig>("m_config");

		public List<ExtensionMapping> m_extensionMappings => method_3<Class271<ExtensionMapping>>("m_extensionMappings")?.method_25();

		public uint m_nextDuckStateTweenId => method_2<uint>("m_nextDuckStateTweenId");

		public List<MusicTrack> m_musicTracks => method_3<Class271<MusicTrack>>("m_musicTracks")?.method_25();

		public List<MusicTrack> m_ambienceTracks => method_3<Class271<MusicTrack>>("m_ambienceTracks")?.method_25();

		public bool m_musicIsAboutToPlay => method_2<bool>("m_musicIsAboutToPlay");

		public bool m_ambienceIsAboutToPlay => method_2<bool>("m_ambienceIsAboutToPlay");

		public int m_musicTrackIndex => method_2<int>("m_musicTrackIndex");

		public int m_ambienceTrackIndex => method_2<int>("m_ambienceTrackIndex");

		public bool m_mute => method_2<bool>("m_mute");

		public int m_nextSourceId => method_2<int>("m_nextSourceId");

		public uint m_frame => method_2<uint>("m_frame");

		public static AssetReference m_fallbackSound => MonoClass.smethod_7<AssetReference>(TritonHs.MainAssemblyPath, "", "SoundManager", "m_fallbackSound");

		public SoundManager(IntPtr address, string className)
			: base(address, className)
		{
		}

		public SoundManager(IntPtr address)
			: this(address, "SoundManager")
		{
		}

		public static SoundManager Get()
		{
			return MonoClass.smethod_15<SoundManager>(TritonHs.MainAssemblyPath, "", "SoundManager", "Get", Array.Empty<object>());
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public void Start()
		{
			method_8("Start");
		}

		public void Update()
		{
			method_8("Update");
		}

		public SoundConfig GetConfig()
		{
			return method_14<SoundConfig>("GetConfig", Array.Empty<object>());
		}

		public void SetConfig(SoundConfig config)
		{
			method_8("SetConfig", config);
		}

		public bool IsInitialized()
		{
			return method_11<bool>("IsInitialized", Array.Empty<object>());
		}

		public GameObject GetPlaceholderSound()
		{
			return method_14<GameObject>("GetPlaceholderSound", Array.Empty<object>());
		}

		public bool Load(string soundPath)
		{
			return method_11<bool>("Load", new object[1] { soundPath });
		}

		public void LoadAndPlay(AssetReference assetRef)
		{
			method_9("LoadAndPlay", new Class276.Enum20[1] { Class276.Enum20.Class }, assetRef);
		}

		public void LoadAndPlay(AssetReference assetRef, float volume)
		{
			method_9("LoadAndPlay", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.R4
			}, assetRef, volume);
		}

		public void LoadAndPlay(AssetReference assetRef, GameObject parent)
		{
			method_9("LoadAndPlay", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Class
			}, assetRef, parent);
		}

		public void LoadAndPlay(AssetReference assetRef, GameObject parent, float volume)
		{
			method_9("LoadAndPlay", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Class,
				Class276.Enum20.R4
			}, assetRef, parent, volume);
		}

		public void OnLoadSoundLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnLoadSoundLoaded", assetRef, go, callbackData);
		}

		public void OnLoadAndPlaySoundLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnLoadAndPlaySoundLoaded", assetRef, go, callbackData);
		}

		public List<MusicTrack> GetCurrentMusicTracks()
		{
			return method_14<Class271<MusicTrack>>("GetCurrentMusicTracks", Array.Empty<object>())?.method_25();
		}

		public List<MusicTrack> GetCurrentAmbienceTracks()
		{
			return method_14<Class271<MusicTrack>>("GetCurrentAmbienceTracks", Array.Empty<object>())?.method_25();
		}

		public void StopCurrentMusicTrack()
		{
			method_8("StopCurrentMusicTrack");
		}

		public void StopCurrentAmbienceTrack()
		{
			method_8("StopCurrentAmbienceTrack");
		}

		public void NukeMusicAndAmbiencePlaylists()
		{
			method_8("NukeMusicAndAmbiencePlaylists");
		}

		public void NukePlaylistsAndStopPlayingCurrentTracks()
		{
			method_8("NukePlaylistsAndStopPlayingCurrentTracks");
		}

		public void NukeMusicAndStopPlayingCurrentTrack()
		{
			method_8("NukeMusicAndStopPlayingCurrentTrack");
		}

		public void NukeAmbienceAndStopPlayingCurrentTrack()
		{
			method_8("NukeAmbienceAndStopPlayingCurrentTrack");
		}

		public void ImmediatelyKillMusicAndAmbience()
		{
			method_8("ImmediatelyKillMusicAndAmbience");
		}

		public void OnMusicLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnMusicLoaded", assetRef, go, callbackData);
		}

		public void OnAmbienceLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnAmbienceLoaded", assetRef, go, callbackData);
		}

		public void UpdateMusicAndAmbience()
		{
			method_8("UpdateMusicAndAmbience");
		}

		public bool PlayNextMusic()
		{
			return method_11<bool>("PlayNextMusic", Array.Empty<object>());
		}

		public bool PlayNextAmbience()
		{
			return method_11<bool>("PlayNextAmbience", Array.Empty<object>());
		}

		public void UpdateCategoryMute(SoundCategory cat)
		{
			method_8("UpdateCategoryMute", cat);
		}

		public void UpdateAllMutes()
		{
			method_8("UpdateAllMutes");
		}

		public void UpdateCategoryVolume(SoundCategory cat)
		{
			method_8("UpdateCategoryVolume", cat);
		}

		public void UpdateAllCategoryVolumes()
		{
			method_8("UpdateAllCategoryVolumes");
		}

		public void InitializeOptions()
		{
			method_8("InitializeOptions");
		}

		public void OnMasterEnabledOptionChanged(Option option, object prevValue, bool existed, object userData)
		{
			method_8("OnMasterEnabledOptionChanged", option, prevValue, existed, userData);
		}

		public void OnMasterVolumeOptionChanged(Option option, object prevValue, bool existed, object userData)
		{
			method_8("OnMasterVolumeOptionChanged", option, prevValue, existed, userData);
		}

		public void OnEnabledOptionChanged(Option option, object prevValue, bool existed, object userData)
		{
			method_8("OnEnabledOptionChanged", option, prevValue, existed, userData);
		}

		public void OnVolumeOptionChanged(Option option, object prevValue, bool existed, object userData)
		{
			method_8("OnVolumeOptionChanged", option, prevValue, existed, userData);
		}

		public void OnBackgroundSoundOptionChanged(Option option, object prevValue, bool existed, object userData)
		{
			method_8("OnBackgroundSoundOptionChanged", option, prevValue, existed, userData);
		}

		public SoundPlaybackLimitClipDef FindClipDefInPlaybackDef(string clipName, SoundPlaybackLimitDef def)
		{
			return method_14<SoundPlaybackLimitClipDef>("FindClipDefInPlaybackDef", new object[2] { clipName, def });
		}

		public bool StartDucking(SoundDucker ducker)
		{
			return method_11<bool>("StartDucking", new object[1] { ducker });
		}

		public void StopDucking(SoundDucker ducker)
		{
			method_8("StopDucking", ducker);
		}

		public DuckState RegisterDuckState(object trigger, SoundDuckedCategoryDef duckedCatDef)
		{
			return method_14<DuckState>("RegisterDuckState", new object[2] { trigger, duckedCatDef });
		}

		public uint GetNextDuckStateTweenId()
		{
			return method_11<uint>("GetNextDuckStateTweenId", Array.Empty<object>());
		}

		public void ChangeDuckState(DuckState state, DuckMode mode)
		{
			method_8("ChangeDuckState", state, mode);
		}

		public void AnimateBeginningDuckState(DuckState state)
		{
			method_8("AnimateBeginningDuckState", state);
		}

		public void OnDuckStateBeginningComplete(DuckState state)
		{
			method_8("OnDuckStateBeginningComplete", state);
		}

		public void AnimateRestoringDuckState(DuckState state)
		{
			method_8("AnimateRestoringDuckState", state);
		}

		public void OnDuckStateRestoringComplete(DuckState state)
		{
			method_8("OnDuckStateRestoringComplete", state);
		}

		public SoundDuckingDef FindDuckingDefForCategory(SoundCategory cat)
		{
			return method_14<SoundDuckingDef>("FindDuckingDefForCategory", new object[1] { cat });
		}

		public float GetDuckingVolume(SoundCategory cat)
		{
			return method_10<float>("GetDuckingVolume", new Class276.Enum20[1] { Class276.Enum20.ValueType }, new object[1] { cat });
		}

		public int GetNextSourceId()
		{
			return method_11<int>("GetNextSourceId", Array.Empty<object>());
		}

		public void OnAppFocusChanged(bool focus, object userData)
		{
			method_8("OnAppFocusChanged", focus, userData);
		}

		public void UpdateAppMute()
		{
			method_8("UpdateAppMute");
		}

		public void OnSceneLoaded(SceneMgr.Mode mode, PegasusScene scene, object userData)
		{
			method_8("OnSceneLoaded", mode, scene, userData);
		}

		public void UnloadSoundBundle(AssetReference assetRef)
		{
			method_8("UnloadSoundBundle", assetRef);
		}

		public void GarbageCollectBundles()
		{
			method_8("GarbageCollectBundles");
		}

		public void UpdateMusicAndSources()
		{
			method_8("UpdateMusicAndSources");
		}

		public void UpdateSources()
		{
			method_8("UpdateSources");
		}

		public void UpdateSourceExtensionMappings()
		{
			method_8("UpdateSourceExtensionMappings");
		}

		public void UpdateSourcesByCategory()
		{
			method_8("UpdateSourcesByCategory");
		}

		public void UpdateSourcesByClipName()
		{
			method_8("UpdateSourcesByClipName");
		}

		public void UpdateSourceBundles()
		{
			method_8("UpdateSourceBundles");
		}

		public void UpdateGeneratedSources()
		{
			method_8("UpdateGeneratedSources");
		}

		public void UpdateDuckStates()
		{
			method_8("UpdateDuckStates");
		}

		public void CleanInactiveSources()
		{
			method_8("CleanInactiveSources");
		}

		public void PrintAllCategorySources()
		{
			method_8("PrintAllCategorySources");
		}
	}
}
